﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
////给定两个以字符串形式表⽰的⾮负整数 num1 和 num2 ，返回 num1 和
////num2 的乘积，它们的乘积也表⽰为字符串形式
//
//class Solution {
//public:
//	string multiply(string num1, string num2) {
//		// 如果其中⼀个数为0，则结果为0
//		if (num1 == "0" || num2 == "0") {
//			return "0";
//		}
//		// 两个数反转，⽅便从低位到⾼位相乘
//		reverse(num1.begin(), num1.end());
//		reverse(num2.begin(), num2.end());
//		// 两数相乘，其结果⻓度不会超过两数⻓度之和，先全部初始化为'0'
//		string ans(num1.size() + num2.size(), '0');
//		int carry = 0; // 进位
//		// 逐位相乘
//		for (int i = 0; i < num1.size(); ++i) {
//			for (int j = 0; j < num2.size(); ++j) {
//				// 当前位的结果等于之前的进位加上两数当前位的乘积和之前计算的结果
//				carry += (num1[i] - '0') * (num2[j] - '0') + (ans[i + j] -
//					'0');
//				// 计算当前位的结果，保存到结果中
//				ans[i + j] = '0' + carry % 10;
//				// 更新进位
//				carry /= 10;
//			}
//			// 如果最后还有进位，将进位加到结果中
//			if (carry > 0) {
//				ans[i + num2.size()] = ('0' + carry);
//				carry = 0;
//			}
//		}
//		// 如果最⾼位为0（即未被使⽤），则去掉最⾼位
//		if (ans.back() == '0') {
//			ans.pop_back();
//		}
//		// 将结果反转回正确的顺序
//		reverse(ans.begin(), ans.end());
//		// 返回结果
//		return ans;
//	}
//};

//日期类实现
class Date {
public:
	friend ostream& operator<<(ostream& out, const Date& d);
	// 获取某年某⽉的天数
	int GetMonthDay(int year, int month) {
		static int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,
		30, 31 };
		int day = days[month];
		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400
			== 0)) {
			day += 1;
		}
		return day;
	}
	Date(int year = 1900, int month = 1, int day = 1) {
		if (year < 1900
			|| month < 1 || month > 12
			|| day < 1 || day > GetMonthDay(year, month)) {
			cout << "非法日期" << endl;
		}
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d) {
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	Date& operator=(const Date& d) {
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	Date& operator-=(int day) {
		if (day < 0)
		{
			return *this += -day;
		}
		_day -= day;
		while (_day <= 0)
		{
			_month--;
			if (_month < 1)
			{
				_month = 12;
				_year--;
			}
			_day += GetMonthDay(_year, _month);
		}
		return *this;
	}
	Date& operator+=(int day) {
		if (day < 0) {
			return *this -= -day;
		}
		_day += day;
		while (_day > GetMonthDay(_year, _month)) {
			_day -= GetMonthDay(_year, _month);
			_month++;
			if (_month > 12) {
				_month = 1;
				_year++;
			}
		}
		return *this;
	}
	Date operator+(int day) {
		Date ret(*this);
		ret += day;
		return ret;
	}
	Date operator-(int day) {
		Date ret(*this);
		ret -= day;
		return ret;
	}
	bool operator==(const Date& d) {
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& out, const Date& d) {
	out << d._year << "-" << d._month << "-" << d._day;
	return out;
}
int main() {
	Date date(2020, 2, 20);
	date += -10;
	Date date2 = date + 100;
	cout << date << endl;
	cout << date2 << endl;
	cout << (date == date2);
	return 0;
}

////模拟实现priority_queue类
//#include <cstring>
//#include <vector>
//#include <functional>
//template <class T, class Container = std::vector<T>, class Compare = less<T>>
//class priority_queue {
//public:
//	// 创建空的优先级队列
//	priority_queue() : c() {}
//	template <class InputIterator>
//	priority_queue(InputIterator first, InputIterator last)
//		: c(first, last) {
//		// 将c中的元素调整为堆的结构，默认为⼤堆
//		int count = static_cast<int>(c.size());
//		int root = ((count - 2) >> 1);
//		for (; root >= 0; root--)
//			AdjustDown(root);
//	}
//	bool empty() const {
//		return c.empty();
//	}
//	size_t size() const {
//		return c.size();
//	}
//	// 堆顶元素不允许修改，因为：堆顶元素修改可以会破坏堆的特性
//	const T& top() const {
//		return c.front();
//	}
//	void push(const T& x) {
//		c.push_back(x);
//		AdjustUp(static_cast<int>(c.size()) - 1);
//	}
//	void pop() {
//		if (empty())
//			return;
//		std::swap(c.front(), c.back());
//		c.pop_back();
//		AdjustDown(0);
//	}
//private:
//	// 向上调整
//	void AdjustUp(int child) {
//		int parent = ((child - 1) >> 1);
//		while (child > 0) { // 确保child不是根节点
//			if (Com(c[parent], c[child])) {
//				std::swap(c[child], c[parent]);
//				child = parent;
//				parent = ((child - 1) >> 1);
//			}
//			else
//				return;
//		}
//	}
//	// 向下调整
//	void AdjustDown(int parent) {
//		int child = parent * 2 + 1; // 左孩⼦
//		int size = static_cast<int>(c.size());
//		while (child < size) {
//			// 找以parent为根的较⼤的孩⼦
//			if (child + 1 < size && Com(c[child], c[child + 1]))
//				child += 1;
//			// 检测双亲是否满⾜情况
//			if (Com(c[parent], c[child])) {
//				std::swap(c[child], c[parent]);
//				parent = child;
//				child = parent * 2 + 1;
//			}
//			else
//				return;
//		}
//	}
//private:
//	Container c;
//	Compare Com;
//};
//int main() {
//	priority_queue<int> pq;
//	pq.push(10);
//	pq.push(20);
//	pq.push(30);
//	cout << pq.top() << endl;
//	pq.pop();
//	pq.pop();
//	cout << pq.top();
//	return 0;
//}
